Software Development
Advanced Programming in Go
Advanced Programming in Go: Accessing Databases
it_gpapgdj_05_enus
Advanced Programming in Go: Best Practices for Go Programming
it_gpapgdj_07_enus
Advanced Programming in Go: Concurrency
it_gpapgdj_02_enus
Advanced Programming in Go: Deep Dive into Packages
it_gpapgdj_01_enus
Advanced Programming in Go: Go Channels
it_gpapgdj_04_enus
Advanced Programming in Go: Goroutines
it_gpapgdj_03_enus
Advanced Programming in Go: Testing & Deploying Go Programs
it_gpapgdj_06_enus
Advanced Programming in Go: Accessing Databases
Lesson Objectives
Advanced Programming in Go: Accessing Databases
- discover the key concepts covered in this course
- describe how databases are accessed in Go programs
- install MySQL database in a local development environment
- create a MySQL database and populate it with data using MySQL Workbench
- install a database driver to connect to a database with Go code
- perform read operations against a database in Go
- create and use prepared statements in relation to databases in Go programs
- perform create, update, and delete operations against a database in Go
- implement transactions against a database in Go
- use an intrinsic approach in Go for handling errors, null values, and unknown columns
- summarize the key concepts covered in this course
Overview/Description
The ecosystems of mainstream programming languages include various types of client mechanisms for interacting with common databases, including both SQL and NoSQL databases. The Go programming language is no exception. The Go ecosystem contains multiple libraries for building and using SQL and several drivers for connecting with and operating on different databases. In this course, explore how databases are accessed from Go programs. Work with databases by implementing a database driver for Go. Experiment by performing various operations and transactions on the database. Work with prepared statements. Finish up by practicing how to handle errors, null values, and unknown columns. Upon completion, you'll be able to perform several routine database operations from your Go program.
The ecosystems of mainstream programming languages include various types of client mechanisms for interacting with common databases, including both SQL and NoSQL databases. The Go programming language is no exception. The Go ecosystem contains multiple libraries for building and using SQL and several drivers for connecting with and operating on different databases. In this course, explore how databases are accessed from Go programs. Work with databases by implementing a database driver for Go. Experiment by performing various operations and transactions on the database. Work with prepared statements. Finish up by practicing how to handle errors, null values, and unknown columns. Upon completion, you'll be able to perform several routine database operations from your Go program.
Target
Prerequisites: none
Advanced Programming in Go: Best Practices for Go Programming
Lesson Objectives
Advanced Programming in Go: Best Practices for Go Programming
- discover the key concepts covered in this course
- describe best practice concepts related to programming in Go
- outline best practices for organizing Go code, with reference to code structure, naming conventions, and comments
- use best practices and Go's native methods for documenting and obtaining information about Go programs
- create an effective directory structure for organizing Go code using best practices
- describe best practices related to error handling in Go programs
- follow a best practice approach to error handling in Go programs
- describe best practices related to data handling in Go programs
- follow a best practice approach to data handling in Go programs
- describe best practices related to concurrency in Go programs
- follow a best practice approach to concurrency in Go programs
- describe best practices related to testing Go programs
- follow a best practice approach to testing Go programs
- summarize the key concepts covered in this course
Overview/Description
Adopting and employing best practices in software development not only mitigates virtually all levels of risk but also naturally results in high-quality, secure, and maintainable software. Consequently, professional software development organizations typically take care to observe best practices. Use this course to learn some of the most significant best practices when programming in Go. Study approaches to organizing Go code and documenting Go programs. Examine best practices related to error handling, data handling, concurrency, and testing. Then, finish off by implementing some of these best practices in a Go program. When you're done, you'll be able to leverage the benefits of a best practice approach when programming in Go.
Adopting and employing best practices in software development not only mitigates virtually all levels of risk but also naturally results in high-quality, secure, and maintainable software. Consequently, professional software development organizations typically take care to observe best practices. Use this course to learn some of the most significant best practices when programming in Go. Study approaches to organizing Go code and documenting Go programs. Examine best practices related to error handling, data handling, concurrency, and testing. Then, finish off by implementing some of these best practices in a Go program. When you're done, you'll be able to leverage the benefits of a best practice approach when programming in Go.
Target
Prerequisites: none
Advanced Programming in Go: Concurrency
Lesson Objectives
Advanced Programming in Go: Concurrency
- discover the key concepts covered in this course
- recognize sequential programming concepts
- compare and contrast single-threaded programming versus multi-threaded programming
- describe the concepts underlying concurrency and parallelism
- describe why concurrency is particularly useful in specific scenarios
- describe how concurrency is implemented in Go programs
- describe concurrency primitives typically used in Go programs
- describe confinement options in Go programming
- describe common concurrency patterns used in Go programs
- create and execute a Go program to improve performance with concurrency
- summarize the key concepts covered in this course
Overview/Description
Concurrency is a critical component of modern software, as it is capable of leveraging modern hardware advances. Concurrent applications can execute various parts of a program out of sequence while not affecting the final outcome of the program. This is often confused with parallelism, which involves running multiple programs simultaneously. In this course, you'll explore the concept of concurrency by first considering sequential programming. With that foundation, you'll dive into multi-threaded programming and learn about the differences between concurrency and parallelism. Next, you'll examine Go's concurrency model and the concurrency primitives used in Go to build concurrent applications. Finally, you'll learn about concurrency patterns used in Go programming and how performance can be improved with concurrency.
Concurrency is a critical component of modern software, as it is capable of leveraging modern hardware advances. Concurrent applications can execute various parts of a program out of sequence while not affecting the final outcome of the program. This is often confused with parallelism, which involves running multiple programs simultaneously. In this course, you'll explore the concept of concurrency by first considering sequential programming. With that foundation, you'll dive into multi-threaded programming and learn about the differences between concurrency and parallelism. Next, you'll examine Go's concurrency model and the concurrency primitives used in Go to build concurrent applications. Finally, you'll learn about concurrency patterns used in Go programming and how performance can be improved with concurrency.
Target
Prerequisites: none
Advanced Programming in Go: Deep Dive into Packages
Lesson Objectives
Advanced Programming in Go: Deep Dive into Packages
- discover the key concepts covered in this course
- define what a package is in Go programming
- describe why packages are used in Go programming
- employ best practices for naming packages and package components
- create and use nested packages in Go
- declare and configure packages in Go
- import packages and identify when to use a blank import
- use alternative methods for importing packages
- document custom packages in Go
- recognize best practices for working with packages
- recognize when and how to use the init() function to initialize an application
- create and work with modules and packages
- summarize the key concepts covered in this course
Overview/Description
All Go programs are composed of one or more packages. Packages organize Go source code in a way that makes the code easily reusable and readable. Packages essentially allow you to take one or more source code files and compartmentalize them into a single unit. In this course, you'll explore what Go packages are and why they are used. You'll examine best practice for working with Go packages and learn about working with modules and packages. Next, you'll learn about package names and how to declare and import packages. Finally, you'll explore how to create and use custom packages and nested packages, as well as how to use the init() function in Go to initialize an application.
All Go programs are composed of one or more packages. Packages organize Go source code in a way that makes the code easily reusable and readable. Packages essentially allow you to take one or more source code files and compartmentalize them into a single unit. In this course, you'll explore what Go packages are and why they are used. You'll examine best practice for working with Go packages and learn about working with modules and packages. Next, you'll learn about package names and how to declare and import packages. Finally, you'll explore how to create and use custom packages and nested packages, as well as how to use the init() function in Go to initialize an application.
Target
Prerequisites: none
Advanced Programming in Go: Go Channels
Lesson Objectives
Advanced Programming in Go: Go Channels
- discover the key concepts covered in this course
- describe Go channels and how they fit in Go's overall concurrency model
- create and use a channel for communicating in Goroutines
- create and work with buffered and unbuffered channels in Goroutines
- use the range() and close() functions in the context of channels in Go
- describe how to implement non-blocking channel operations in Go programs
- use select to process channel operations
- use a default clause to implement non-blocking channel operations
- combine channels and WaitGroups with Goroutines
- describe pipelines and list common pipeline patterns
- create and implement a pipeline in a Go program
- summarize the key concepts covered in this course
Overview/Description
Go channels are constructs used by Goroutines to communicate with each other. Go channels, which can be buffered or unbuffered, are similar to pipes in that one Goroutine can send data from one side of the pipe to other Goroutines that receive the data on the other side. In this course, you'll explore how channels fit in Go's overall concurrency model. You'll learn how to implement non-blocking channel operations in Go programs and about the use of pipelines in Go. Next, you'll examine how to work with Goroutines, as well as buffered and unbuffered channels. You'll explore the range() and close() functions in the context of channels and learn how to combine channels and WaitGroups. Lastly, you'll learn how to implement a pipeline in a Go program.
Go channels are constructs used by Goroutines to communicate with each other. Go channels, which can be buffered or unbuffered, are similar to pipes in that one Goroutine can send data from one side of the pipe to other Goroutines that receive the data on the other side. In this course, you'll explore how channels fit in Go's overall concurrency model. You'll learn how to implement non-blocking channel operations in Go programs and about the use of pipelines in Go. Next, you'll examine how to work with Goroutines, as well as buffered and unbuffered channels. You'll explore the range() and close() functions in the context of channels and learn how to combine channels and WaitGroups. Lastly, you'll learn how to implement a pipeline in a Go program.
Target
Prerequisites: none
Advanced Programming in Go: Goroutines
Lesson Objectives
Advanced Programming in Go: Goroutines
- discover the key concepts covered in this course
- describe Goroutines and how they fit in Go's concurrency model
- create and execute a simple Goroutine
- work with Goroutines and closures
- work with anonymous Goroutines
- describe how the packages sync and sync/atomic are used in concurrent programming
- create and use WaitGroups in Goroutines
- define and execute atomic operations in Go
- create and use Mutexes in Go programs
- describe race conditions and how they affect Go programs
- simulate a race condition in a Go program and study its affects
- compare and contrast race conditions versus data race conditions
- utilize programming methods to avoid race conditions
- utilize programming tools in Go that help detect race conditions
- summarize the key concepts covered in this course
Overview/Description
Goroutines are foundational components of Go's concurrency model. Goroutines may be considered units of execution in a Go program. Goroutines are very lightweight with small stack sizes. Consequently, millions of Goroutines may be spawned at about the same time on modest hardware. In this course, you'll explore Goroutines and how they implement the packages sync and sync/atomic. You'll investigate race conditions in Goroutines and explore race conditions versus data races. Next, you'll create and work with WaitGroups, implement atomic operations and see how mutexes are used with Goroutines. Lastly, you'll create and explore how to detect and avoid race conditions in Goroutines.
Goroutines are foundational components of Go's concurrency model. Goroutines may be considered units of execution in a Go program. Goroutines are very lightweight with small stack sizes. Consequently, millions of Goroutines may be spawned at about the same time on modest hardware. In this course, you'll explore Goroutines and how they implement the packages sync and sync/atomic. You'll investigate race conditions in Goroutines and explore race conditions versus data races. Next, you'll create and work with WaitGroups, implement atomic operations and see how mutexes are used with Goroutines. Lastly, you'll create and explore how to detect and avoid race conditions in Goroutines.
Target
Prerequisites: none
Advanced Programming in Go: Testing & Deploying Go Programs
Lesson Objectives
Advanced Programming in Go: Testing & Deploying Go Programs
- discover the key concepts covered in this course
- describe the various test techniques commonly employed with Go programs
- outline typical approaches to debugging Go programs
- follow a process for systematically debugging a Go program
- implement unit testing against a Go program
- measure test coverage while testing a Go program
- build and install Go programs to local on-premises machines
- recognize the deployment tools and techniques used for Go applications and deploy a Go program to a cloud provider
- deploy a Go program to a cloud provider
- summarize the key concepts covered in this course
Overview/Description
Testing and debugging a program is fundamental to creating quality software. Likewise, deployment is an indispensable software development step, which must be navigated appropriately. The Go ecosystem includes several options and approaches for both testing/debugging and deploying Go programs. Use this course to learn the various testing and debugging approaches common to Go programs. Experiment by executing unit tests against Go software. Perform tests based on test coverage metrics. Learn common approaches for debugging Go programs. Lastly, examine tools and techniques for deploying Go applications both on-premises and to the Cloud and practice deploying a Go program to a cloud provider. Upon completion, you'll be able to use Go to test, debug, build, and deploy Go programs.
Testing and debugging a program is fundamental to creating quality software. Likewise, deployment is an indispensable software development step, which must be navigated appropriately. The Go ecosystem includes several options and approaches for both testing/debugging and deploying Go programs. Use this course to learn the various testing and debugging approaches common to Go programs. Experiment by executing unit tests against Go software. Perform tests based on test coverage metrics. Learn common approaches for debugging Go programs. Lastly, examine tools and techniques for deploying Go applications both on-premises and to the Cloud and practice deploying a Go program to a cloud provider. Upon completion, you'll be able to use Go to test, debug, build, and deploy Go programs.
Target
Prerequisites: none
